// openaiTtsService.js - Updated with support for voice instructions

import { getAudioDuration } from '../util/ffmpeg'

process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

import { execFile } from 'child_process';
import util from 'util';
const execFilePromise = util.promisify(execFile);
import fs from 'fs';
import path from 'path';
import { app } from 'electron';
import OpenAI from 'openai';
import { getRandomEnabledApiKey } from '../dao/apiKeys.js';
import { getProxyConfig } from '../dao/proxyConfig.js';

// 获取应用数据目录，用于保存合成的音频文件
const getSynthesizedAudioDir = () => {
  const userDataPath = app.getPath('userData');
  const audioDir = path.join(userDataPath, 'synthesized_audio');

  // 确保目录存在
  if (!fs.existsSync(audioDir)) {
    fs.mkdirSync(audioDir, { recursive: true });
  }

  return audioDir;
};

/**
 * 将文本转换为语音
 * @param {string} text - 要转换的文本
 * @param {string} model - 使用的模型: 'tts-1', 'tts-1-hd', 'gpt-4o-audio-preview', 'gpt-4o-mini-tts'
 * @param {string} voice - 使用的语音，如 'alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'
 * @param {number} language - 文本语言，可以在提示中使用
 * @param {string} instructions - 可选的语音特性指令，用于 gpt-4o-mini-tts 模型
 * @returns {Promise<object>} - 返回包含路径和时长的对象
 */
export const textToSpeech = async (text, model = 'tts-1', voice = 'alloy', language = null, instructions = null) => {
  console.log("执行audio generation");
  console.log(language)

  // 从数据库获取随机启用的API密钥
  const apiKeyData = getRandomEnabledApiKey();

  if (!apiKeyData) {
    throw new Error('没有启用的API密钥，请在API密钥管理页面添加并启用至少一个密钥');
  }

  // 获取代理配置
  const proxyConfig = getProxyConfig();

  try {
    console.log('初始化OpenAI客户端');
    console.log(`使用API密钥: ${apiKeyData.name}`);
    console.log(`使用模型: ${model}, 语音: ${voice}`);

    if (instructions) {
      console.log(`使用语音指令: ${instructions}`);
    }

    // 根据代理配置创建OpenAI客户端
    const openaiConfig = {
      apiKey: apiKeyData.key
    };

    // 如果代理启用，则使用代理URL
    if (proxyConfig && proxyConfig.enabled) {
      console.log(`使用代理: ${proxyConfig.proxy_url}`);
      openaiConfig.baseURL = proxyConfig.proxy_url;
    }

    const openai = new OpenAI(openaiConfig);

    let filePath;
    let duration;

    // 处理新的 gpt-4o-mini-tts 模型
    if (model === 'gpt-4o-mini-tts') {
      console.log('发送gpt-4o-mini-tts音频生成请求:', {
        model,
        voice,
        instructionsLength: instructions ? instructions.length : 0,
        textLength: text.length
      });

      // 使用 gpt-4o-mini-tts API
      const response = await openai.audio.speech.create({
        model: model,
        voice: voice,
        input: text,
        instructions: instructions || undefined  // 如果有语音指令则传递
      });

      // 生成唯一文件名
      const timestamp = Date.now();
      const fileName = `speech_${timestamp}.mp3`;
      filePath = path.join(getSynthesizedAudioDir(), fileName);

      console.log('保存gpt-4o-mini-tts音频文件:', filePath);

      // 将arrayBuffer转换为Buffer并写入文件
      const buffer = Buffer.from(await response.arrayBuffer());
      await fs.promises.writeFile(filePath, buffer);

      // 估算音频时长
      duration = await getAudioDuration(filePath)
    }
    // 处理GPT-4o音频预览模型
    else if (model === 'gpt-4o-audio-preview' || model === 'gpt-4o-mini-audio-preview') {
      // 构建消息内容
      let prompt = text;
      if (language) {
        prompt = `Please speak this text in ${language}: ${text}`;
      }

      // 如果提供了指令，添加到提示中
      if (instructions) {
        prompt = `${instructions}\n\n${prompt}`;
      }

      console.log('发送GPT-4o音频生成请求:', {
        model,
        voice,
        language,
        textLength: text.length
      });

      // 使用GPT-4o音频生成API
      const response = await openai.chat.completions.create({
        model: model,
        modalities: ["text", "audio"],
        audio: { voice: voice, format: "mp3" },
        messages: [
          {
            role: "user",
            content: prompt
          }
        ],
        store: true,
      });

      // 从响应中提取音频数据
      const audioData = response.choices[0].message.audio.data;

      // 生成唯一文件名
      const timestamp = Date.now();
      const randomNum = Math.floor(1000 + Math.random() * 9000);
      const fileName = `speech_${timestamp}_${randomNum}.mp3`;
      filePath = path.join(getSynthesizedAudioDir(), fileName);

      console.log('保存GPT-4o音频文件:', filePath);

      // 将base64编码的音频数据写入文件
      fs.writeFileSync(
        filePath,
        Buffer.from(audioData, 'base64')
      );

      // 估算音频时长
      duration = await getAudioDuration(filePath)
    }
    // 处理传统TTS模型
    else {
      console.log('发送TTS音频生成请求:', {
        model,
        voice,
        textLength: text.length
      });

      // 使用TTS API直接生成语音
      const mp3 = await openai.audio.speech.create({
        model: model,
        voice: voice,
        input: text,
      });

      // 生成唯一文件名
      const timestamp = Date.now();
      const fileName = `speech_${timestamp}.mp3`;
      filePath = path.join(getSynthesizedAudioDir(), fileName);

      console.log('保存TTS音频文件:', filePath);

      // 将arrayBuffer转换为Buffer并写入文件
      const buffer = Buffer.from(await mp3.arrayBuffer());
      await fs.promises.writeFile(filePath, buffer);

      // 估算音频时长
      duration = await getAudioDuration(filePath)
    }

    return {
      path: filePath,
      duration: duration // 返回估计的音频时长（秒）
    };
  } catch (error) {
    console.error('OpenAI音频生成失败:', error);

    // 提取并记录错误详细信息
    if (error.response) {
      console.error('错误状态:', error.response.status);
      console.error('错误详情:', error.response.data);
    }

    throw new Error(`音频生成失败: ${error.message}`);
  }
};

/**
 * 使用OpenAI进行文本翻译
 * @param {string} text - 要翻译的文本
 * @param {string} sourceLang - 源语言（可选）
 * @param {string} targetLang - 目标语言
 * @returns {Promise<string>} - 返回翻译后的文本
 */
export const translateText = async (text, sourceLang = 'auto', targetLang = 'zh-CN') => {
  console.log("执行OpenAI翻译");

  // 从数据库获取随机启用的API密钥
  const apiKeyData = getRandomEnabledApiKey();

  if (!apiKeyData) {
    throw new Error('没有启用的API密钥，请在API密钥管理页面添加并启用至少一个密钥');
  }

  // 获取代理配置
  const proxyConfig = getProxyConfig();

  try {
    console.log('初始化OpenAI客户端');
    console.log(`使用API密钥: ${apiKeyData.name}`);

    // 根据代理配置创建OpenAI客户端
    const openaiConfig = {
      apiKey: apiKeyData.key
    };

    // 如果代理启用，则使用代理URL
    if (proxyConfig && proxyConfig.enabled) {
      console.log(`使用代理: ${proxyConfig.proxy_url}`);
      openaiConfig.baseURL = proxyConfig.proxy_url;
    }

    const openai = new OpenAI(openaiConfig);

    // 构建翻译提示
    let prompt = '';
    if (sourceLang === 'auto') {
      prompt = `请将以下文本翻译成${targetLang}：\n\n${text}`;
    } else {
      prompt = `请将以下${sourceLang}文本翻译成${targetLang}：\n\n${text}`;
    }

    console.log('发送翻译请求:', {
      textLength: text.length
    });

    // 使用OpenAI API进行翻译
    const response = await openai.chat.completions.create({
      model: 'gpt-4o-mini',  // 使用高质量翻译模型
      messages: [
        {
          role: 'system',
          content: '你是一个专业的翻译工具，请提供准确、流畅、自然的翻译，直接返回翻译结果，不要添加任何额外解释。'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      temperature: 0.3,  // 较低的温度确保更稳定的翻译
    });

    // 提取翻译结果
    const translatedText = response.choices[0].message.content.trim();

    console.log('翻译完成，原文长度:', text.length, '翻译后长度:', translatedText.length);

    return translatedText;
  } catch (error) {
    console.error('OpenAI翻译失败:', error);

    // 提取并记录错误详细信息
    if (error.response) {
      console.error('错误状态:', error.response.status);
      console.error('错误详情:', error.response.data);
    }

    throw new Error(`翻译失败: ${error.message}`);
  }
};

/**
 * 批量翻译多个文本项
 * @param {Array<Object>} items - 要翻译的项目列表，每项包含id, text等字段
 * @param {string} targetLang - 目标语言
 * @returns {Promise<Array<Object>>} - 返回翻译后的项目列表
 */
export const batchTranslate = async (items, targetLang = 'zh-CN') => {
  console.log(`批量翻译 ${items.length} 个项目到 ${targetLang}`);

  const results = [];

  for (const item of items) {
    try {
      console.log(`翻译项目 ID: ${item.id}, 名称: ${item.name}`);

      // 翻译标题和内容
      const [translatedName, translatedText] = await Promise.all([
        item.name ? translateText(item.name, 'auto', targetLang) : Promise.resolve(item.name),
        translateText(item.text, 'auto', targetLang)
      ]);

      results.push({
        ...item,
        name: translatedName || item.name,
        text: translatedText
      });

    } catch (error) {
      console.error(`翻译项目 ID: ${item.id} 失败:`, error);
      // 翻译失败时保留原始文本
      results.push(item);
    }
  }

  return results;
};


// /**
//  * 使用 ffprobe 获取音频文件的时长（秒）
//  */
// export async function getAudioDuration(filePath) {
//   try {
//     const { stdout } = await execFilePromise('ffprobe', [
//       '-v', 'error',
//       '-show_entries', 'format=duration',
//       '-of', 'default=noprint_wrappers=1:nokey=1',
//       filePath
//     ]);
//     return parseFloat(stdout.trim());
//   } catch (err) {
//     console.error('获取音频时长失败:', err);
//     return -1; // 或者默认值
//   }
// }
